home *** CD-ROM | disk | FTP | other *** search
/ BCI NET / BCI NET Dec 94.iso / archives / programming / libraries / mui20dev.lha / MUI / Developer / Modula / txt / MuiMacros.mod < prev    next >
Text File  |  1994-02-10  |  27KB  |  874 lines
  1. IMPLEMENTATION MODULE MuiMacros;
  2.  
  3. (*$ NilChk      := FALSE *)
  4. (*$ EntryClear  := FALSE *)
  5. (*$ LargeVars   := FALSE *)
  6. (*$ StackParms  := FALSE *)
  7. (*$ DEFINE Locale :=FALSE *)
  8.  
  9.  
  10. (****************************************************************************
  11. **
  12. **      MUI Macros 2.0
  13. **
  14. **      Converted to Modula by Christian "Kochtopf" Scholz
  15. **
  16. **      $Id: MuiMacros.mod,v 1.4 1994/02/09 14:50:03 Kochtopf Exp $
  17. **
  18. **      $Log: MuiMacros.mod,v $
  19. # Revision 1.4  1994/02/09  14:50:03  Kochtopf
  20. # Versionsnummer in 2.0 geaendert.
  21. #
  22. **
  23. ****************************************************************************)
  24.  
  25. IMPORT  MD:MuiD;
  26. IMPORT  ML:MuiL;
  27. IMPORT  UD:UtilityD;
  28. IMPORT  R;
  29. FROM    MuiSupport IMPORT DoMethod;
  30. FROM    UtilityD IMPORT tagEnd, tagMore, HookPtr, Hook;
  31. FROM    SYSTEM IMPORT ADDRESS, ADR, TAG, CAST, SETREG, REG;
  32. FROM    IntuitionL IMPORT SetAttrsA, GetAttr;
  33. FROM    IntuitionD IMPORT omGET, omADDMEMBER, omREMMEMBER;
  34. FROM    Storage IMPORT ALLOCATE;
  35.  
  36. VAR buffer  : ARRAY [0..50] OF LONGINT;      (* for the tags *)
  37.  
  38. (*
  39. **
  40. **  MUI - Object Generation
  41. **
  42. *)
  43.  
  44. PROCEDURE WindowObject(tags : UD.TagItemPtr) : APTR;
  45.     BEGIN
  46.         RETURN ML.mNewObject(ADR(MD.mcWindow), tags);
  47.     END WindowObject;
  48.  
  49. PROCEDURE ImageObject(tags : UD.TagItemPtr) : APTR;
  50.     BEGIN
  51.         RETURN ML.mNewObject(ADR(MD.mcImage), tags);
  52.     END ImageObject;
  53.  
  54. PROCEDURE ApplicationObject(tags : UD.TagItemPtr) : APTR;
  55.     BEGIN
  56.         RETURN ML.mNewObject(ADR(MD.mcApplication), tags);
  57.     END ApplicationObject;
  58.  
  59. PROCEDURE NotifyObject(tags : UD.TagItemPtr) : APTR;
  60.     BEGIN
  61.         RETURN ML.mNewObject(ADR(MD.mcNotify), tags);
  62.     END NotifyObject;
  63.  
  64. PROCEDURE TextObject(tags : UD.TagItemPtr) : APTR;
  65.     BEGIN
  66.         RETURN ML.mNewObject(ADR(MD.mcText), tags);
  67.     END TextObject;
  68.  
  69. PROCEDURE RectangleObject(tags : UD.TagItemPtr) : APTR;
  70.     BEGIN
  71.         RETURN ML.mNewObject(ADR(MD.mcRectangle), tags);
  72.     END RectangleObject;
  73.  
  74. PROCEDURE ListObject(tags : UD.TagItemPtr) : APTR;
  75.     BEGIN
  76.         RETURN ML.mNewObject(ADR(MD.mcList), tags);
  77.     END ListObject;
  78.  
  79. PROCEDURE PropObject(tags : UD.TagItemPtr) : APTR;
  80.     BEGIN
  81.         RETURN ML.mNewObject(ADR(MD.mcProp), tags);
  82.     END PropObject;
  83.  
  84. PROCEDURE StringObject(tags : UD.TagItemPtr) : APTR;
  85.     BEGIN
  86.         RETURN ML.mNewObject(ADR(MD.mcString), tags);
  87.     END StringObject;
  88.  
  89. PROCEDURE ScrollbarObject(tags : UD.TagItemPtr) : APTR;
  90.     BEGIN
  91.         RETURN ML.mNewObject(ADR(MD.mcScrollbar), tags);
  92.     END ScrollbarObject;
  93.  
  94. PROCEDURE ListviewObject(tags : UD.TagItemPtr) : APTR;
  95.     BEGIN
  96.         RETURN ML.mNewObject(ADR(MD.mcListview), tags);
  97.     END ListviewObject;
  98.  
  99. PROCEDURE RadioObject(tags : UD.TagItemPtr) : APTR;
  100.     BEGIN
  101.         RETURN ML.mNewObject(ADR(MD.mcRadio), tags);
  102.     END RadioObject;
  103.  
  104. PROCEDURE VolumelistObject(tags : UD.TagItemPtr) : APTR;
  105.     BEGIN
  106.         RETURN ML.mNewObject(ADR(MD.mcVolumelist), tags);
  107.     END VolumelistObject;
  108.  
  109. PROCEDURE FloattextObject(tags : UD.TagItemPtr) : APTR;
  110.     BEGIN
  111.         RETURN ML.mNewObject(ADR(MD.mcFloattext), tags);
  112.     END FloattextObject;
  113.  
  114. PROCEDURE DirlistObject(tags : UD.TagItemPtr) : APTR;
  115.     BEGIN
  116.         RETURN ML.mNewObject(ADR(MD.mcDirlist), tags);
  117.     END DirlistObject;
  118.  
  119. PROCEDURE ScrmodelistObject(tags : UD.TagItemPtr) : APTR;
  120.     BEGIN
  121.         RETURN ML.mNewObject(ADR(MD.mcScrmodelist), tags);
  122.     END ScrmodelistObject;
  123.  
  124. (* Not implemented!
  125. PROCEDURE ApplistObject(tags : UD.TagItemPtr) : APTR;
  126.     BEGIN
  127.         RETURN ML.mNewObject(ADR(MD.mcApplist), tags);
  128.     END ApplistObject;
  129.  
  130. PROCEDURE DatatypeObject(tags : UD.TagItemPtr) : APTR;
  131.     BEGIN
  132.         RETURN ML.mNewObject(ADR(MD.mcDatatype), tags);
  133.     END DatatypeObject; 
  134. *)
  135.  
  136. PROCEDURE SliderObject(tags : UD.TagItemPtr) : APTR;
  137.     BEGIN
  138.         RETURN ML.mNewObject(ADR(MD.mcSlider), tags);
  139.     END SliderObject;
  140.  
  141. PROCEDURE CycleObject(tags : UD.TagItemPtr) : APTR;
  142.     BEGIN
  143.         RETURN ML.mNewObject(ADR(MD.mcCycle), tags);
  144.     END CycleObject;
  145.  
  146. PROCEDURE GaugeObject(tags : UD.TagItemPtr) : APTR;
  147.     BEGIN
  148.         RETURN ML.mNewObject(ADR(MD.mcGauge), tags);
  149.     END GaugeObject;
  150.  
  151. PROCEDURE BoopsiObject(tags : UD.TagItemPtr) : APTR;
  152.     BEGIN
  153.         RETURN ML.mNewObject(ADR(MD.mcBoopsi), tags);
  154.     END BoopsiObject;
  155.  
  156. PROCEDURE ScaleObject(tags : UD.TagItemPtr) : APTR;
  157.     BEGIN
  158.         RETURN ML.mNewObject(ADR(MD.mcScale), tags);
  159.     END ScaleObject;
  160.  
  161. PROCEDURE GroupObject(tags : UD.TagItemPtr) : APTR;
  162.     BEGIN
  163.         RETURN ML.mNewObject(ADR(MD.mcGroup), tags);
  164.     END GroupObject;
  165.  
  166. PROCEDURE VGroup(tags : UD.TagItemPtr) : APTR;
  167.     BEGIN
  168.         RETURN ML.mNewObject(ADR(MD.mcGroup), tags);
  169.     END VGroup;
  170.  
  171. PROCEDURE HGroup(tags : UD.TagItemPtr) : APTR;
  172.     BEGIN
  173.         RETURN ML.mNewObject(ADR(MD.mcGroup), TAG(buffer, MD.maGroupHoriz, TRUE, tagMore, tags, tagEnd));
  174.     END HGroup;
  175.  
  176. PROCEDURE ColGroup(cols : LONGCARD; tags : UD.TagItemPtr) : APTR;
  177.     BEGIN
  178.         RETURN ML.mNewObject(ADR(MD.mcGroup), TAG(buffer, MD.maGroupColumns, cols, tagMore, tags, tagEnd));
  179.     END ColGroup;
  180.  
  181. PROCEDURE RowGroup(rows : LONGCARD; tags : UD.TagItemPtr) : APTR;
  182.     BEGIN
  183.         RETURN ML.mNewObject(ADR(MD.mcGroup), TAG(buffer, MD.maGroupRows, rows, tagMore, tags, tagEnd));
  184.     END RowGroup;
  185.  
  186. PROCEDURE PageGroup(tags : UD.TagItemPtr) : APTR;
  187.     BEGIN
  188.          RETURN ML.mNewObject(ADR(MD.mcGroup),TAG(buffer, MD.maGroupPageMode, TRUE, tagMore, tags, tagEnd));
  189.     END PageGroup;
  190.  
  191. PROCEDURE ColorfieldObject(tags : UD.TagItemPtr) : APTR;
  192.     BEGIN
  193.          RETURN ML.mNewObject(ADR(MD.mcColorfield), tags);
  194.     END ColorfieldObject;
  195.  
  196. PROCEDURE ColoradjustObject(tags : UD.TagItemPtr) : APTR;
  197.     BEGIN
  198.          RETURN ML.mNewObject(ADR(MD.mcColoradjust), tags);
  199.     END ColoradjustObject;
  200.  
  201. PROCEDURE PaletteObject(tags : UD.TagItemPtr) : APTR;
  202.     BEGIN
  203.          RETURN ML.mNewObject(ADR(MD.mcPalette), tags);
  204.     END PaletteObject;
  205.  
  206. PROCEDURE VirtgroupObject(tags : UD.TagItemPtr) : APTR;
  207.     BEGIN
  208.          RETURN ML.mNewObject(ADR(MD.mcVirtgroup), tags);
  209.     END VirtgroupObject;
  210.  
  211. PROCEDURE ScrollgroupObject(tags : UD.TagItemPtr) : APTR;
  212.     BEGIN
  213.          RETURN ML.mNewObject(ADR(MD.mcScrollgroup), tags);
  214.     END ScrollgroupObject;
  215.  
  216. PROCEDURE VGroupV(tags : UD.TagItemPtr) : APTR;
  217.     BEGIN
  218.          RETURN ML.mNewObject(ADR(MD.mcVirtgroup), tags);
  219.     END VGroupV;
  220.  
  221. PROCEDURE HGroupV(tags : UD.TagItemPtr) : APTR;
  222.     BEGIN
  223.         RETURN ML.mNewObject(ADR(MD.mcVirtgroup), TAG(buffer, MD.maGroupHoriz, TRUE, tagMore, tags, tagEnd));
  224.     END HGroupV;
  225.  
  226. PROCEDURE ColGroupV(cols : LONGCARD; tags : UD.TagItemPtr) : APTR;
  227.     BEGIN
  228.         RETURN ML.mNewObject(ADR(MD.mcVirtgroup), TAG(buffer, MD.maGroupColumns, cols, tagMore, tags, tagEnd));
  229.     END ColGroupV;
  230.  
  231. PROCEDURE RowGroupV(rows : LONGCARD; tags : UD.TagItemPtr) : APTR;
  232.     BEGIN
  233.         RETURN ML.mNewObject(ADR(MD.mcVirtgroup), TAG(buffer, MD.maGroupRows, rows, tagMore, tags, tagEnd));
  234.     END RowGroupV;
  235.  
  236. PROCEDURE PageGroupV(tags : UD.TagItemPtr) : APTR;
  237.     BEGIN
  238.          RETURN ML.mNewObject(ADR(MD.mcVirtgroup),TAG(buffer, MD.maGroupPageMode, TRUE, tagMore, tags, tagEnd));
  239.     END PageGroupV;
  240.  
  241. (* missing Defs!
  242. PROCEDURE Popstring(tags : UD.TagItemPtr) : APTR;
  243.     BEGIN
  244.          RETURN ML.mNewObject(ADR(MD.mcPopstring), tags);
  245.     END Popstring;
  246.  
  247. PROCEDURE Popobject(tags : UD.TagItemPtr) : APTR;
  248.     BEGIN
  249.          RETURN ML.mNewObject(ADR(MD.mcPopobject), tags);
  250.     END Popobject;
  251.  
  252. PROCEDURE Popasl(tags : UD.TagItemPtr) : APTR;
  253.     BEGIN
  254.          RETURN ML.mNewObject(ADR(MD.mcPopasl), tags);
  255.     END Popasl;
  256. *)
  257.  
  258.  
  259. (*
  260. **  MakeID
  261. **  Generate an ID out of a 4-char-string.
  262. **  Use it the as WindowID ! (look in MuiTest for an example!)
  263. *)
  264.  
  265. PROCEDURE MakeID (name : ShortString): LONGINT;
  266.  
  267.     BEGIN
  268.         RETURN ORD(name[0])+
  269.                ORD(name[1])*256+
  270.                ORD(name[2])*65536+
  271.                ORD(name[3])*16777216;
  272.     END MakeID;
  273.  
  274.  
  275.  
  276.  
  277. (*
  278. **  Hook-Support functions
  279. **  1. the dispatcher
  280. **  2. the MakeHook-Function
  281. **
  282. *)
  283.  
  284. PROCEDURE HookEntry(hook{R.A0}  : HookPtr;
  285.                     object{R.A2}: ADDRESS;
  286.                     args{R.A1}  : ADDRESS)     : ADDRESS;
  287.     (*$SaveA4:=TRUE*)
  288.     BEGIN
  289.         SETREG (R.A4, hook^.data);
  290.         RETURN CAST(HookDef,hook^.subEntry)(hook, object, args);
  291.     END HookEntry;
  292.  
  293. PROCEDURE MakeHook(entry:HookDef; VAR hook : HookPtr);
  294.  
  295.     BEGIN
  296.             ALLOCATE(hook,SIZE(Hook));
  297.             hook^.node.succ  := NIL;
  298.             hook^.node.pred  := NIL;
  299.             hook^.entry      := HookEntry;
  300.             hook^.subEntry   := CAST(ADDRESS,entry);
  301.             hook^.data       := REG(R.A4);
  302.     END MakeHook;
  303.  
  304.  
  305.  
  306. (*
  307. **
  308. **  Spacing Macros
  309. **
  310. *)
  311.  
  312. PROCEDURE HVSpace() : APTR;
  313.     BEGIN
  314.         RETURN ML.mNewObject(ADR(MD.mcRectangle), NIL);
  315.     END HVSpace;
  316.  
  317. PROCEDURE HSpace(x : LONGCARD) : APTR;
  318.     BEGIN
  319.         IF x#0 THEN 
  320.                 RETURN ML.mNewObject(ADR(MD.mcRectangle),
  321.                                      TAG(buffer,
  322.                                         MD.maFixWidth,     x,
  323.                                         MD.maVertWeight,   0,
  324.                                         tagEnd));
  325.                 ELSE   
  326.                 RETURN ML.mNewObject(ADR(MD.mcRectangle),
  327.                                      TAG(buffer,
  328.                                         MD.maVertWeight,   0,
  329.                                         tagEnd));
  330.                 END;
  331.     END HSpace;
  332.  
  333. PROCEDURE VSpace(x : LONGCARD) : APTR;
  334.     BEGIN
  335.         IF x#0 THEN 
  336.                 RETURN ML.mNewObject(ADR(MD.mcRectangle),
  337.                                      TAG(buffer,
  338.                                         MD.maFixHeight,     x,
  339.                                         MD.maHorizWeight,   0,
  340.                                         tagEnd));
  341.                 ELSE
  342.                 RETURN ML.mNewObject(ADR(MD.mcRectangle),
  343.                                      TAG(buffer,
  344.                                         MD.maHorizWeight,   0,
  345.                                         tagEnd));
  346.                 END;
  347.     END VSpace;
  348.  
  349.  
  350. (*
  351. **
  352. **  PopUp-Macro
  353. **
  354. *)
  355.  
  356. PROCEDURE Popup (object : APTR; 
  357.                  hook : HookPtr; 
  358.              VAR imageObj : APTR;
  359.                  imgSpec : ADDRESS) : APTR;
  360.     VAR
  361.         dummy    : APTR;
  362.         buffer   : ARRAY[0..20] OF LONGINT;
  363.  
  364.     BEGIN
  365.         imageObj := ImageObject(TAG(buffer,
  366.                         MD.maFrame,                 MD.mvFrameImageButton,
  367.                         MD.maImageSpec,             imgSpec,
  368.                         MD.maImageFontMatchWidth,   TRUE,
  369.                         MD.maImageFreeVert,         TRUE,
  370.                         MD.maInputMode,             MD.mvInputModeRelVerify,
  371.                         MD.maBackground,            MD.miBACKGROUND,
  372.                         tagEnd));
  373.  
  374.         dummy :=    HGroup(TAG(buffer,
  375.                         MD.maGroupSpacing,      1,
  376.                         Child,                  object,
  377.                         Child,                  imageObj,
  378.                         tagEnd));
  379.  
  380.         IF (dummy#NIL) AND (imageObj#NIL) THEN
  381.             DoMethod(imageObj, TAG(buffer, MD.mmNotify,
  382.                         MD.maPressed, FALSE,
  383.                         dummy, 2,
  384.                         MD.mmCallHook, hook));
  385.                         RETURN dummy;
  386.         END;
  387.         RETURN 0;
  388.  
  389.     END Popup;
  390.  
  391.  
  392. (*
  393. **
  394. ** String-Object
  395. **
  396. ** Makes a simple String-Gadget
  397. **
  398. *)
  399.  
  400.  
  401. (*$ IF Locale *)
  402. PROCEDURE String(contents : StrPtr; maxlen : LONGINT) : APTR;
  403. (*$ ELSE *)
  404. (*$ CopyDyn := FALSE *)
  405. PROCEDURE String(contents : ARRAY OF CHAR; maxlen : LONGINT) : APTR;
  406. (*$ ENDIF *)
  407.     BEGIN
  408.         RETURN StringObject(TAG(buffer,
  409.                             MD.maFrame,            MD.mvFrameString,
  410.                             MD.maStringMaxLen,     maxlen,
  411.                             (*$ IF Locale *)
  412.                                 MD.maStringContents,   contents,
  413.                             (*$ ELSE *)
  414.                                 MD.maStringContents,   ADR(contents),
  415.                             (*$ ENDIF *)
  416.                             tagEnd));
  417.     END String;
  418. (*$ IF Locale *)
  419. PROCEDURE KeyString(contents : StrPtr; maxlen : LONGINT; key : CHAR) : APTR;
  420. (*$ ELSE *)
  421. (*$ CopyDyn := FALSE *)
  422. PROCEDURE KeyString(contents : ARRAY OF CHAR; maxlen : LONGINT; key : CHAR) : APTR;
  423. (*$ ENDIF *)
  424.     BEGIN
  425.         RETURN StringObject(TAG(buffer,
  426.                             MD.maFrame,             MD.mvFrameString,
  427.                             MD.maStringMaxLen,      maxlen,
  428.                             (*$ IF Locale *)
  429.                                 MD.maStringContents,    contents,
  430.                             (*$ ELSE *)
  431.                                 MD.maStringContents,    ADR(contents),
  432.                             (*$ ENDIF *)
  433.                             MD.maControlChar,       key,
  434.                             tagEnd));
  435.     END KeyString;
  436.  
  437. (*
  438. **
  439. ** Checkmark
  440. **
  441. *)
  442.  
  443. PROCEDURE Checkmark(selected : BOOLEAN) : APTR;
  444.     BEGIN
  445.         RETURN ImageObject( TAG(buffer,
  446.                             MD.maFrame,            MD.mvFrameImageButton,
  447.                             MD.maInputMode,        MD.mvInputModeToggle,
  448.                             MD.maImageSpec,        MD.miCheckMark,
  449.                             MD.maImageFreeVert,    TRUE,
  450.                             MD.maSelected,         selected,
  451.                             MD.maBackground,       MD.miButtonBack,
  452.                             MD.maShowSelState,     FALSE,
  453.                             tagEnd));
  454.     END Checkmark;
  455.  
  456. PROCEDURE KeyCheckmark(selected : BOOLEAN; key : CHAR) : APTR;
  457.     BEGIN
  458.         RETURN ImageObject( TAG(buffer,
  459.                             MD.maFrame,            MD.mvFrameImageButton,
  460.                             MD.maInputMode,        MD.mvInputModeToggle,
  461.                             MD.maImageSpec,        MD.miCheckMark,
  462.                             MD.maImageFreeVert,    TRUE,
  463.                             MD.maSelected,         selected,
  464.                             MD.maBackground,       MD.miButtonBack,
  465.                             MD.maShowSelState,     FALSE,
  466.                             MD.maControlChar,      key,
  467.                             tagEnd));
  468.     END KeyCheckmark;
  469.  
  470. (*
  471. **
  472. ** Buttons
  473. **
  474. *)
  475.  
  476. (*$ IF Locale *)
  477. PROCEDURE Simplebutton(name : StrPtr) : APTR;
  478. (*$ ELSE *)
  479. (*$ CopyDyn := FALSE *)
  480. PROCEDURE Simplebutton(name : ARRAY OF CHAR) : APTR;
  481. (*$ ENDIF *)
  482.     BEGIN
  483.         RETURN TextObject(  TAG(buffer,
  484.                             MD.maFrame,            MD.mvFrameButton,
  485.                             (*$ IF Locale *)
  486.                                 MD.maTextContents,     name,
  487.                             (*$ ELSE *)
  488.                                 MD.maTextContents,     ADR(name),
  489.                             (*$ ENDIF *)
  490.                             MD.maTextPreParse,     ADR("\033c"),
  491.                             MD.maTextSetMax,       FALSE,
  492.                             MD.maInputMode,        MD.mvInputModeRelVerify,
  493.                             MD.maBackground,       MD.miButtonBack,
  494.                             tagEnd));
  495.  
  496.     END Simplebutton;
  497.  
  498. (*$ IF Locale *)
  499. PROCEDURE Keybutton(name : StrPtr; key : CHAR) : APTR;
  500. (*$ ELSE *)
  501. (*$ CopyDyn := FALSE *)
  502. PROCEDURE Keybutton(name : ARRAY OF CHAR; key : CHAR) : APTR;
  503. (*$ ENDIF *)
  504.     BEGIN
  505.         RETURN TextObject(  TAG(buffer,
  506.                             MD.maFrame,            MD.mvFrameButton,
  507.                             (*$ IF Locale *)
  508.                                 MD.maTextContents,     name,
  509.                             (*$ ELSE *)
  510.                                 MD.maTextContents,     ADR(name),
  511.                             (*$ ENDIF *)
  512.                             MD.maTextPreParse,     ADR("\033c"),
  513.                             MD.maTextSetMax,       FALSE,
  514.                             MD.maTextHiChar,       key,
  515.                             MD.maControlChar,      key,
  516.                             MD.maInputMode,        MD.mvInputModeRelVerify,
  517.                             MD.maBackground,       MD.miButtonBack,
  518.                             tagEnd));
  519.  
  520.     END Keybutton;
  521.  
  522.  
  523.  
  524. (*
  525. **
  526. **  Radio Object
  527. **
  528. *)
  529.  
  530. (*$ IF Locale *)
  531. PROCEDURE Radio(name : StrPtr; array : APTR) : APTR;
  532. (*$ ELSE *)
  533. (*$ CopyDyn := FALSE *)
  534. PROCEDURE Radio(name : ARRAY OF CHAR; array : APTR) : APTR;
  535. (*$ ENDIF *)
  536.     BEGIN
  537.         RETURN RadioObject( TAG(buffer,
  538.                             MD.maFrame,             MD.mvFrameGroup,
  539.                             (*$ IF Locale *)
  540.                                 MD.maFrameTitle,        name,
  541.                             (*$ ELSE *)
  542.                                 MD.maFrameTitle,        ADR(name),
  543.                             (*$ ENDIF *)
  544.                             MD.maRadioEntries,      array,
  545.                             tagEnd));
  546.     END Radio;
  547.  
  548. (*$ IF Locale *)
  549. PROCEDURE KeyRadio(name : StrPtr; array : APTR; key : CHAR) : APTR;
  550. (*$ ELSE *)
  551. (*$ CopyDyn := FALSE *)
  552. PROCEDURE KeyRadio(name : ARRAY OF CHAR; array : APTR; key : CHAR) : APTR;
  553. (*$ ENDIF *)
  554.     BEGIN
  555.         RETURN RadioObject( TAG(buffer,
  556.                             MD.maFrame,             MD.mvFrameGroup,
  557.                             (*$ IF Locale *)
  558.                                 MD.maFrameTitle,        name,
  559.                             (*$ ELSE *)
  560.                                 MD.maFrameTitle,        ADR(name),
  561.                             (*$ ENDIF *)
  562.                             MD.maTextHiChar,        key,
  563.                             MD.maControlChar,       key,
  564.                             MD.maRadioEntries,      array,
  565.                             tagEnd));
  566.     END KeyRadio;
  567.  
  568.  
  569. (*
  570. **
  571. ** Label Objects
  572. **
  573. *)
  574.  
  575. (*$ IF Locale *)
  576. PROCEDURE Label(label : StrPtr) : APTR;
  577. (*$ ELSE *)
  578. (*$ CopyDyn := FALSE *)
  579. PROCEDURE Label(label : ARRAY OF CHAR) : APTR;
  580. (*$ ENDIF *)
  581.     BEGIN
  582.         RETURN TextObject(  TAG(buffer,
  583.                             MD.maTextPreParse,         ADR("\033r"),
  584.                             (*$ IF Locale *)
  585.                                 MD.maTextContents,         label,
  586.                             (*$ ELSE *)
  587.                                 MD.maTextContents,         ADR(label),
  588.                             (*$ ENDIF *)
  589.                             MD.maWeight,               0,
  590.                             MD.maInnerLeft,            0,
  591.                             MD.maInnerRight,           0,
  592.                             tagEnd));
  593.     END Label;
  594.  
  595.  
  596. (*$ IF Locale *)
  597. PROCEDURE Label1(label : StrPtr) : APTR;
  598. (*$ ELSE *)
  599. (*$ CopyDyn := FALSE *)
  600. PROCEDURE Label1(label : ARRAY OF CHAR) : APTR;
  601. (*$ ENDIF *)
  602.     BEGIN
  603.         RETURN TextObject(  TAG(buffer,
  604.                             MD.maTextPreParse,         ADR("\033r"),
  605.                             (*$ IF Locale *)
  606.                                 MD.maTextContents,         label,
  607.                             (*$ ELSE *)
  608.                                 MD.maTextContents,         ADR(label),
  609.                             (*$ ENDIF *)
  610.                             MD.maWeight,               0,
  611.                             MD.maInnerLeft,            0,
  612.                             MD.maInnerRight,           0,
  613.                             MD.maFrame,                MD.mvFrameButton,
  614.                             MD.maFramePhantomHoriz,    TRUE,
  615.                             tagEnd));
  616.     END Label1;
  617.  
  618.  
  619. (*$ IF Locale *)
  620. PROCEDURE Label2(label : StrPtr) : APTR;
  621. (*$ ELSE *)
  622. (*$ CopyDyn := FALSE *)
  623. PROCEDURE Label2(label : ARRAY OF CHAR) : APTR;
  624. (*$ ENDIF *)
  625.     BEGIN
  626.         RETURN TextObject(  TAG(buffer,
  627.                             MD.maTextPreParse,         ADR("\033r"),
  628.                             (*$ IF Locale *)
  629.                                 MD.maTextContents,         label,
  630.                             (*$ ELSE *)
  631.                                 MD.maTextContents,         ADR(label),
  632.                             (*$ ENDIF *)
  633.                             MD.maWeight,               0,
  634.                             MD.maInnerLeft,            0,
  635.                             MD.maInnerRight,           0,
  636.                             MD.maFrame,                MD.mvFrameString,
  637.                             MD.maFramePhantomHoriz,    TRUE,
  638.                             tagEnd));
  639.     END Label2;
  640.  
  641.  
  642. (*$ IF Locale *)
  643. PROCEDURE KeyLabel(label : StrPtr; HiChar : CHAR) : APTR;
  644. (*$ ELSE *)
  645. (*$ CopyDyn := FALSE *)
  646. PROCEDURE KeyLabel(label : ARRAY OF CHAR; HiChar : CHAR) : APTR;
  647. (*$ ENDIF *)
  648.     BEGIN
  649.         RETURN TextObject(  TAG(buffer,
  650.                             MD.maTextPreParse,         ADR("\033r"),
  651.                             (*$ IF Locale *)
  652.                                 MD.maTextContents,         label,
  653.                             (*$ ELSE *)
  654.                                 MD.maTextContents,         ADR(label),
  655.                             (*$ ENDIF *)
  656.                             MD.maWeight,               0,
  657.                             MD.maInnerLeft,            0,
  658.                             MD.maInnerRight,           0,
  659.                             MD.maTextHiChar,           HiChar,
  660.                             tagEnd));
  661.     END KeyLabel;
  662.  
  663.  
  664. (*$ IF Locale *)
  665. PROCEDURE KeyLabel1(label : StrPtr; HiChar : CHAR) : APTR;
  666. (*$ ELSE *)
  667. (*$ CopyDyn := FALSE *)
  668. PROCEDURE KeyLabel1(label : ARRAY OF CHAR; HiChar : CHAR) : APTR;
  669. (*$ ENDIF *)
  670.     BEGIN
  671.         RETURN TextObject(  TAG(buffer,
  672.                             MD.maTextPreParse,         ADR("\033r"),
  673.                             (*$ IF Locale *)
  674.                                 MD.maTextContents,         label,
  675.                             (*$ ELSE *)
  676.                                 MD.maTextContents,         ADR(label),
  677.                             (*$ ENDIF *)
  678.                             MD.maWeight,               0,
  679.                             MD.maInnerLeft,            0,
  680.                             MD.maInnerRight,           0,
  681.                             MD.maTextHiChar,           HiChar,
  682.                             MD.maFrame,                MD.mvFrameButton,
  683.                             MD.maFramePhantomHoriz,    TRUE,
  684.                             tagEnd));
  685.     END KeyLabel1;
  686.  
  687.  
  688. (*$ IF Locale *)
  689. PROCEDURE KeyLabel2(label : StrPtr; HiChar : CHAR) : APTR;
  690. (*$ ELSE *)
  691. (*$ CopyDyn := FALSE *)
  692. PROCEDURE KeyLabel2(label : ARRAY OF CHAR; HiChar : CHAR) : APTR;
  693. (*$ ENDIF *)
  694.     BEGIN
  695.         RETURN TextObject(  TAG(buffer,
  696.                             MD.maTextPreParse,         ADR("\033r"),
  697.                             (*$ IF Locale *)
  698.                                 MD.maTextContents,         label,
  699.                             (*$ ELSE *)
  700.                                 MD.maTextContents,         ADR(label),
  701.                             (*$ ENDIF *)
  702.                             MD.maWeight,               0,
  703.                             MD.maInnerLeft,            0,
  704.                             MD.maInnerRight,           0,
  705.                             MD.maTextHiChar,           HiChar,
  706.                             MD.maFrame,                MD.mvFrameString,
  707.                             MD.maFramePhantomHoriz,    TRUE,
  708.                             tagEnd));
  709.     END KeyLabel2;
  710.  
  711. (*
  712. **
  713. **  Cycle-Objects
  714. **
  715. *)
  716.  
  717. PROCEDURE Cycle(array : APTR) : APTR;
  718.     BEGIN
  719.         RETURN CycleObject(TAG(buffer,
  720.                             MD.maCycleEntries,      array,
  721.                             tagEnd));
  722.     END Cycle;
  723.  
  724.  
  725. PROCEDURE KeyCycle(array : APTR; key : CHAR) : APTR;
  726.     BEGIN
  727.         RETURN CycleObject(TAG(buffer,
  728.                             MD.maCycleEntries,      array,
  729.                             MD.maControlChar,       key,
  730.                             tagEnd));
  731.     END KeyCycle;
  732.  
  733.  
  734. (*
  735. **
  736. **  Slider-Objects
  737. **
  738. *)
  739.  
  740. PROCEDURE Slider(min,max,level : LONGINT; horiz : BOOLEAN) : APTR;
  741.     BEGIN
  742.         RETURN SliderObject(TAG(buffer,
  743.                             MD.maGroupHoriz,        horiz,
  744.                             MD.maSliderLevel,       level,
  745.                             MD.maSliderMax,         max,
  746.                             MD.maSliderMin,         min,
  747.                             tagEnd));
  748.     END Slider;
  749.  
  750. PROCEDURE KeySlider(min,max,level : LONGINT; horiz : BOOLEAN;
  751.                         key : CHAR) : APTR;
  752.     BEGIN
  753.         RETURN SliderObject(TAG(buffer,
  754.                             MD.maGroupHoriz,        horiz,
  755.                             MD.maSliderLevel,       level,
  756.                             MD.maSliderMax,         max,
  757.                             MD.maSliderMin,         min,
  758.                             MD.maControlChar,       key,
  759.                             tagEnd));
  760.     END KeySlider;
  761.  
  762.  
  763.  
  764. (*
  765. **
  766. ** Controlling Objects
  767. **
  768. ** Note : get didn't work in previous releases
  769. **
  770. *)
  771.  
  772. PROCEDURE get(obj : APTR; attr : LONGCARD; store : ADDRESS);
  773.     BEGIN
  774.         DoMethod(obj,TAG(buffer, omGET,
  775.             attr, store));
  776.     END get;
  777.  
  778. PROCEDURE set(obj : APTR; attr : LONGCARD; value : LONGINT);
  779.     VAR dummy : APTR;
  780.     BEGIN
  781.         dummy:=SetAttrsA(obj, TAG(buffer,attr,value,tagEnd));
  782.     END set;
  783.  
  784. PROCEDURE setmutex(obj : APTR; n : LONGINT);
  785.     BEGIN
  786.         set(obj,MD.maRadioActive,n);
  787.     END setmutex;
  788.  
  789. PROCEDURE setcycle(obj : APTR; n : LONGINT);
  790.     BEGIN
  791.         set(obj,MD.maCycleActive,n);
  792.     END setcycle;
  793.  
  794. (*$ IF Locale *)
  795. PROCEDURE setstring(obj : APTR; s : StrPtr);
  796.     BEGIN
  797.         set(obj,MD.maStringContents,s);
  798.     END setstring;
  799. (*$ ELSE *)
  800. (*$ CopyDyn := FALSE *)
  801. PROCEDURE setstring(obj : APTR; s : ARRAY OF CHAR);
  802.     BEGIN
  803.         set(obj,MD.maStringContents,ADR(s));
  804.     END setstring;
  805. (*$ ENDIF *)
  806.  
  807. PROCEDURE setcheckmark(obj : APTR; b : BOOLEAN);
  808.     BEGIN
  809.         IF b THEN set(obj,MD.maSelected,1);
  810.              ELSE set(obj,MD.maSelected,0);
  811.              END;
  812.     END setcheckmark;
  813.  
  814. PROCEDURE setslider(obj : APTR; l : LONGINT);
  815.     BEGIN
  816.         set(obj,MD.maSliderLevel,l);
  817.     END setslider;
  818.  
  819.  
  820. (*
  821. ** NoteClose (app,obj,ID)
  822. *)
  823.  
  824. PROCEDURE NoteClose(app : APTR; 
  825.                     obj : APTR; 
  826.                     ID  : LONGINT);
  827.     BEGIN
  828.         DoMethod(obj,TAG(buffer,
  829.                     MD.mmNotify,MD.maWindowCloseRequest,TRUE,
  830.                     app,2,MD.mmApplicationReturnID,ID));
  831.     END NoteClose;
  832.  
  833. (*
  834. **  Notebutton (app,obj,ID)
  835. *)
  836.  
  837. PROCEDURE NoteButton(app : APTR;
  838.                      obj : APTR; 
  839.                      ID  : LONGINT);
  840.     BEGIN
  841.         DoMethod(obj,TAG(buffer,
  842.                         MD.mmNotify,MD.maPressed, FALSE,
  843.                         app,2,MD.mmApplicationReturnID,ID));
  844.     END NoteButton;
  845.  
  846. (*
  847. ** RemMember (obj,member)
  848. *)
  849.  
  850. PROCEDURE RemMember(obj : APTR; member : APTR);
  851.     BEGIN
  852.         DoMethod(obj,TAG(buffer,
  853.                     omREMMEMBER, member));
  854.     END RemMember;
  855.  
  856. (*
  857. ** AddMember (obj,member)
  858. *)
  859.  
  860. PROCEDURE AddMember(obj : APTR; member : APTR);
  861.     BEGIN
  862.         DoMethod(obj,TAG(buffer,
  863.                     omADDMEMBER, member));
  864.     END AddMember;
  865.  
  866. END MuiMacros.
  867.  
  868.  
  869.  
  870.  
  871.  
  872.  
  873.  
  874.